// demo-exec.js
import { exec, execAsync, execNodeScript } from './exec.js';
import { Logger } from './logger.js'; // 确保路径正确

const logger = new Logger('[exec:demo]');

async function runExecDemo() {
  logger.blank();
  logger.title('exec.js 功能演示');

  // --- 1. 同步执行命令 (exec) ---
  logger.blank();
  logger.title('1. 同步执行命令 (exec)');

  // 示例 1.1: 成功执行一个命令 (非静默，输出到控制台)
  logger.info('执行: ls -l (或 dir)');
  try {
    // 根据操作系统选择命令
    const command = process.platform === 'win32' ? 'dir' : 'ls -l';
    exec(command);
    logger.success('ls -l (或 dir) 命令执行成功。');
  } catch (e) {
    logger.error(`ls -l (或 dir) 命令执行失败: ${e.message}`);
  }

  // 示例 1.2: 成功执行一个命令 (静默，捕获输出)
  logger.info('执行: echo "Hello from silent exec" (静默模式)');
  try {
    const output = exec(
      process.platform === 'win32'
        ? 'echo "Hello from silent exec"'
        : 'echo "Hello from silent exec"',
      { silent: true }
    );
    logger.success(`静默执行成功，输出: "${output}"`);
  } catch (e) {
    logger.error(`静默执行失败: ${e.message}`);
  }

  // 示例 1.3: 执行一个会失败的命令 (不忽略错误)
  logger.info('执行: non_existent_command (预期失败)');
  try {
    exec('non_existent_command');
    logger.warning('非预期：non_existent_command 竟然成功了！');
  } catch (e) {
    logger.success(`non_existent_command 预期失败，并捕获到错误: ${e.message.split('\n')[0]}...`);
  }

  // 示例 1.4: 执行一个会失败的命令 (忽略错误)
  logger.info('执行: another_non_existent_command (忽略错误)');
  try {
    const result = exec('another_non_existent_command', { ignoreError: true });
    if (result === null) {
      logger.success('another_non_existent_command 失败但已忽略错误，返回 null。');
    } else {
      logger.warning(`非预期：another_non_existent_command 成功或返回非 null: ${result}`);
    }
  } catch (e) {
    logger.error(`非预期：忽略错误模式下抛出了异常: ${e.message}`);
  }

  // --- 2. 异步执行命令 (execAsync) ---
  logger.blank();
  logger.title('2. 异步执行命令 (execAsync)');

  // 示例 2.1: 成功执行一个命令 (非静默)
  logger.info('执行: git status (非静默)');
  try {
    // 注意：execAsync 的 stdio 默认是 inherit，所以会直接输出到控制台
    await execAsync('git', ['status']);
    logger.success('git status 命令异步执行成功。');
  } catch (e) {
    logger.error(`git status 命令异步执行失败: ${e.message}`);
  }

  // 示例 2.2: 成功执行一个命令 (静默，捕获输出)
  logger.info('执行: node -v (静默模式)');
  try {
    const { stdout } = await execAsync('node', ['-v'], { silent: true });
    logger.success(`node -v 异步静默执行成功，输出: ${stdout.trim()}`);
  } catch (e) {
    logger.error(`node -v 异步静默执行失败: ${e.message}`);
  }

  // 示例 2.3: 执行一个会失败的命令 (异步)
  logger.info('执行: non_existent_async_command (预期异步失败)');
  try {
    await execAsync('non_existent_async_command');
    logger.warning('非预期：non_existent_async_command 竟然异步成功了！');
  } catch (e) {
    logger.success(
      `non_existent_async_command 预期异步失败，并捕获到错误: ${e.message.split('\n')[0]}...`
    );
  }

  // --- 3. 执行 Node 脚本 (execNodeScript) ---
  logger.blank();
  logger.title('3. 执行 Node 脚本 (execNodeScript)');

  // 示例 3.1: 成功执行 Node 脚本
  logger.info('执行: exec-foo-script.js (成功)');
  try {
    await execNodeScript('./utils/exec-foo-script.js');
    logger.success('exec-foo-script.js 成功执行。');
  } catch (e) {
    logger.error(`exec-foo-script.js 执行失败: ${e.message}`);
  }

  // 示例 3.2: 成功执行 Node 脚本并传递参数
  logger.info('执行: exec-foo-script.js --greet "Alice"');
  try {
    await execNodeScript('./utils/exec-foo-script.js', ['--greet', 'Alice']);
    logger.success('exec-foo-script.js 传递参数并成功执行。');
  } catch (e) {
    logger.error(`exec-foo-script.js (带参数) 执行失败: ${e.message}`);
  }

  // 示例 3.3: 执行一个会失败的 Node 脚本
  logger.info('执行: exec-foo-script.js --fail (预期失败)');
  try {
    await execNodeScript('./utils/exec-foo-script.js', ['--fail']);
    logger.warning('非预期：exec-foo-script.js --fail 竟然成功了！');
  } catch (e) {
    logger.success(`exec-foo-script.js --fail 预期失败，并捕获到错误: ${e.message}`);
  }

  logger.blank();
  logger.success('所有演示完成！');
  logger.blank();
}

// 运行演示函数
runExecDemo();
